﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using RiskMan.DataClass.Models.NotBasModels;
using RiskMan.Config;
using RiskMan.Models;
using TheControllerRisk.Settings;
using RiskMan.Properties;
using System.Collections.ObjectModel;


namespace RiskMan.Views.Ledder
{

    class LedderLogik
    {

        private DataClass.Data data;
        private MainWindow mainWindow;
        private Ledder ledder;
        private ObservableCollection<TradesOpen> tmpTradeOpen; //временная коллеция для сортировки и подсчета исполненных заявок на закрытие позиции
        int Deep;

        public LedderLogik()
        { }

        public LedderLogik(MainWindow mainWindow, Ledder ledder)
        {
            this.mainWindow = mainWindow;
            this.data = mainWindow._dataProvider;
            this.ledder = ledder;
        }

        public void Start(LedderItem ldItem)
        {
            //цена последней сделки
            double TTP_Last = mainWindow._dataProvider.GetLastPrice(ldItem.Instrument);
            if (TTP_Last == 0)
                return;
            if (ldItem.StaticsticItem.DateStartTrade.Year==1)
                ldItem.StaticsticItem.DateStartTrade = DateTime.Now;

            string Classcode = mainWindow._dataProvider.GetClasscode(ldItem.Instrument);
            int accuraccy = mainWindow._dataProvider.GetAccuraccy(ldItem.Instrument);
            tmpTradeOpen = new ObservableCollection<TradesOpen>();
            Deep = ldItem.DeepOrders;
            if (Deep <= 0)
                Deep = Properties.Settings.Default.DeepOrders;

            //обрабатываем заявки до начала торгов
            if (ldItem.TradeList!=null)
            if (ldItem.TradeList.Count > 0)
            {
                GetStatusAndBalance(ldItem);
                ldItem.Poz = 0;
                foreach (var item in ldItem.TradeList)
                {
                    if (item.OpenBalance > 0)
                        ldItem.Poz = ldItem.Poz + item.OpenBalance;
                }
            }

            // время работы
            if (new WorkingTimeClass(ldItem.Account).IsWork() == true)
            {
                if (ldItem.TradeList == null || ldItem.TradeList.Count == 0)
                {
                    OpenOrderNew(ldItem, TTP_Last, Classcode, accuraccy, true);
                    OpenOrderShortNew(ldItem, TTP_Last, Classcode, accuraccy, true);
                }

                //если в трейдлисте уже есть заявки
                if (ldItem.TradeList.Count > 0)
                {

                    GetStatusAndBalance(ldItem);

                    //Сортировка коллекций заявок
                    if (ldItem.Operation == cfg.BUY)
                        ldItem.TradeList = new ObservableCollection<TradesOpen>(ldItem.TradeList.OrderBy(i => i.OpenPriceOrder));
                    if (ldItem.Operation == cfg.SELL)
                        ldItem.TradeList = new ObservableCollection<TradesOpen>(ldItem.TradeList.OrderByDescending(i => i.OpenPriceOrder));

                    //высталение заявки на профит первичное, снятии или обнулилась
                    foreach (var item in ldItem.TradeList)
                    {
                        if (BreakOnTransaction() == false)
                        {

                            //снятие заявок на профит при выставленных лишних
                            if (tmpTradeOpen.Count >= ldItem.SumOrdersProfit)
                            {
                                if (item.CloseStatusOrder == cfg.ACTIVE)
                                {
                                    mainWindow.Terminals.CancelOrder(item.CloseNumberOrder, ldItem.Instrument, Classcode, ldItem.Account, ldItem.ClientCode);
                                    item.CloseStatusOrder = null;
                                }
                            }

                            //проверка заявок на закрытие, чтоб не превышало заданное количество
                            if (item.CloseStatusOrder == cfg.ACTIVE && item.OpenStatusOrder == cfg.PERFORMED && tmpTradeOpen.Count < ldItem.SumOrdersProfit)
                                tmpTradeOpen.Add(item);

                            //высталение заявки на профит первично на закрытие позиции
                            if (item.OpenQuantity == item.OpenBalance && tmpTradeOpen.Count < ldItem.SumOrdersProfit && ((item.CloseStatusOrder == null) || (item.CloseStatusOrder == cfg.CANCEL)))
                            {
                                if (item.OpenOperation == "Купля")
                                    AddOrderCloseTotradeList(ldItem, item, Classcode, Math.Round(item.OpenPriceOrder + ldItem.Profit, accuraccy), 'S');

                                if (item.OpenOperation == "Продажа")
                                    AddOrderCloseTotradeList(ldItem, item, Classcode, Math.Round(item.OpenPriceOrder - ldItem.Profit, accuraccy), 'B');

                                tmpTradeOpen.Add(item);

                            }

                            #region перевыставление заявки на открытие если была снята или обнулилась на открытие

                            if (item.OpenQuantity != item.OpenBalance && ((item.OpenStatusOrder == null) || (item.OpenStatusOrder == cfg.CANCEL)))
                            {
                                if (item.OpenOperation == "Купля")
                                    ReplaceOrderOpenTotradeList(ldItem, item, Classcode, item.OpenPriceOrder, 'B');

                                if (item.OpenOperation == "Продажа")
                                    ReplaceOrderOpenTotradeList(ldItem, item, Classcode, item.OpenPriceOrder, 'S');
                            }
                            #endregion
                        }
                        else
                            break;

                    }

                    #region Добавление новых заявок на отрытие и перевыставление
                    //добавление новых заявок на открытие
                    if (BreakOnTransaction() == false)
                    {
                        if (ldItem.Operation == "Купля")
                            OpenOrderNew(ldItem, TTP_Last, Classcode, accuraccy, false);
                        if (ldItem.Operation == "Продажа")
                            OpenOrderShortNew(ldItem, TTP_Last, Classcode, accuraccy, false);

                        //Перевыставление заявок на открытие
                        if (ActiveOrderOpen(ldItem) == ldItem.SumOrders)
                        {
                            if (ldItem.Operation == "Купля")
                                RemoveAndnewOrder(ldItem, TTP_Last, Classcode, accuraccy);
                            if (ldItem.Operation == "Продажа")
                                RemoveAndnewOrderShort(ldItem, TTP_Last, Classcode, accuraccy);
                        }
                    }
                    #endregion
                }
            }
        }

        private bool BreakOnTransaction()
        {
            bool result = false;
            if (Properties.Settings.Default.timeLastTransaction != "")
                if (Convert.ToDateTime(Properties.Settings.Default.timeLastTransaction).TimeOfDay + new TimeSpan(0, 0, 1) >= DateTime.Now.TimeOfDay && Convert.ToDateTime(Properties.Settings.Default.timeLastTransaction).Date == DateTime.Now.Date)
                    if (Properties.Settings.Default.tmpTransactionInTheSeconds >= Properties.Settings.Default.TransactionInTheSeconds)
                        result = true;

            return result;
        }

        /// <summary>
        /// выставляем первый массив заявок на продажу или перестановка или добавление в зависимотси от FirstOpen
        /// </summary>
        /// <param name="ldItem"></param>
        /// <param name="TTP_Last"></param>
        /// <param name="Classcode"></param>
        /// <param name="accuraccy"></param>
        /// <param name="FirstOpen"></param>
        private void OpenOrderShortNew(LedderItem ldItem, double TTP_Last, string Classcode, int accuraccy, bool FirstOpen)
        {
            if (ldItem.Operation == "Продажа")
            {
                double tmpPrice = 0;
                for (int i = 0; i < Deep; i++)
                {
                    if (ldItem.Maxprice - ldItem.Step * i >= TTP_Last)
                        tmpPrice = ldItem.Maxprice - ldItem.Step * i;
                    else
                        break;
                }
                if (tmpPrice > 0)
                    for (int i = 0; i < Deep; i++)
                    {
                        if (BreakOnTransaction() == false)
                        {
                            if (FirstOpen == true)
                            {
                                if (ldItem.TradeList == null)
                                    ldItem.TradeList = new System.Collections.ObjectModel.ObservableCollection<TradesOpen>();

                                if (tmpPrice + ldItem.Step * i >= TTP_Last && tmpPrice + ldItem.Step * i <= ldItem.Maxprice && ldItem.TradeList.Count < ldItem.SumOrders)
                                    AddOrderOpenTotradeList(ldItem, Classcode, Math.Round(tmpPrice + ldItem.Step * i, accuraccy), ldItem.Operation == "Купля" ? 'B' : 'S');

                                if (ldItem.TradeList.Count >= ldItem.SumOrders)
                                {
                                    break;
                                }
                            }
                            else
                            {
                                if (ldItem.Maxprice + ldItem.Step * i >= TTP_Last && tmpPrice + ldItem.Step * i <= ldItem.Maxprice && (ActiveOrderOpen(ldItem) < ldItem.SumOrders))
                                {
                                    if (SearchOpenOrderOnPrice(ldItem, Math.Round(tmpPrice + ldItem.Step * i, accuraccy)) == false)
                                    {
                                        AddOrderOpenTotradeList(ldItem, Classcode, Math.Round(tmpPrice + ldItem.Step * i, accuraccy), ldItem.Operation == "Купля" ? 'B' : 'S');
                                    }
                                }

                            }
                        }
                    }
            }
        }

        /// <summary>
        /// выставляем первый массив заявок на покупку или перестановка или добавление в зависимотси от FirstOpen
        /// </summary>
        /// <param name="ldItem"></param>
        /// <param name="TTP_Last"></param>
        /// <param name="Classcode"></param>
        /// <param name="accuraccy"></param>
        private void OpenOrderNew(LedderItem ldItem, double TTP_Last, string Classcode, int accuraccy, bool FirstOpen)
        {
            if (ldItem.Operation == "Купля")
            {
                for (int i = 0; i < Deep; i++)
                {
                    if (BreakOnTransaction() == false)
                    {
                        if (FirstOpen == true)
                        {
                            if (ldItem.TradeList == null)
                                ldItem.TradeList = new System.Collections.ObjectModel.ObservableCollection<TradesOpen>();

                            if (ldItem.Maxprice - ldItem.Step * i <= TTP_Last && (ldItem.TradeList == null || ldItem.TradeList.Count < ldItem.SumOrders))
                            {
                                AddOrderOpenTotradeList(ldItem, Classcode, Math.Round(ldItem.Maxprice - ldItem.Step * i, accuraccy), ldItem.Operation == "Купля" ? 'B' : 'S');
                            }
                            if (ldItem.TradeList != null && ldItem.TradeList.Count >= ldItem.SumOrders)
                            {
                                break;
                            }
                        }
                        else
                        //Добавление новой заявки
                        {
                            if (ldItem.Maxprice - ldItem.Step * i <= TTP_Last && (ActiveOrderOpen(ldItem) < ldItem.SumOrders))
                            {
                                if (SearchOpenOrderOnPrice(ldItem, Math.Round(ldItem.Maxprice - ldItem.Step * i, accuraccy)) == false)
                                {
                                    AddOrderOpenTotradeList(ldItem, Classcode, Math.Round(ldItem.Maxprice - ldItem.Step * i, accuraccy), ldItem.Operation == "Купля" ? 'B' : 'S');
                                }
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Перевыставление далекой заявки ближе к цене . Заявки на покупку
        /// </summary>
        public void RemoveAndnewOrder(LedderItem ldItem, double TTP_Last, string Classcode, int accuraccy)
        {
            //количество выставленных заявок до заданной цены
            int countActiveOrderToPrice = 0;


            for (int i = 0; i < Deep; i++)
            {
                if (BreakOnTransaction() == false)
                {
                    if (ldItem.Maxprice - ldItem.Step * i <= TTP_Last)
                    {
                        if (SearchOpenOrderOnPrice(ldItem, Math.Round(ldItem.Maxprice - ldItem.Step * i, accuraccy)) == false)
                        {
                            if (countActiveOrderToPrice < ldItem.SumOrders)
                            {
                                if (SearchOrderForKill(ldItem, "Long", Classcode) == true)
                                    AddOrderOpenTotradeList(ldItem, Classcode, Math.Round(ldItem.Maxprice - ldItem.Step * i, accuraccy), ldItem.Operation == "Купля" ? 'B' : 'S');
                                countActiveOrderToPrice = countActiveOrderToPrice + 1;
                            }
                            else
                                break;
                        }
                        else
                        {
                            countActiveOrderToPrice = countActiveOrderToPrice + 1;
                        }
                    }
                }

            }
        }

        /// <summary>
        /// Перевыставление далекой заявки ближе к цене . Заявки на покупку
        /// </summary>
        public void RemoveAndnewOrderShort(LedderItem ldItem, double TTP_Last, string Classcode, int accuraccy)
        {
            //количество выставленных заявок до заданной цены
            int countActiveOrderToPrice = 0;
            double tmpPrice = 0;
            for (int i = 0; i < Deep; i++)
            {
                if (ldItem.Maxprice - ldItem.Step * i >= TTP_Last)
                    tmpPrice = ldItem.Maxprice - ldItem.Step * i;
                else
                    break;
            }
            if (tmpPrice > 0)
            {
                for (int i = 0; i < Deep; i++)
                {
                    if (BreakOnTransaction() == false)
                    {
                        if (tmpPrice + ldItem.Step * i >= TTP_Last && tmpPrice + ldItem.Step * i <= ldItem.Maxprice)
                        {
                            if (SearchOpenOrderOnPrice(ldItem, Math.Round(tmpPrice + ldItem.Step * i, accuraccy)) == false)
                            {
                                if (countActiveOrderToPrice < ldItem.SumOrders)
                                {
                                    if (SearchOrderForKill(ldItem, "Short", Classcode) == true)
                                    {
                                        if (Math.Round(tmpPrice + ldItem.Step * i, accuraccy) == 124100)
                                        { }
                                        AddOrderOpenTotradeList(ldItem, Classcode, Math.Round(tmpPrice + ldItem.Step * i, accuraccy), ldItem.Operation == "Купля" ? 'B' : 'S');
                                    }
                                    countActiveOrderToPrice = countActiveOrderToPrice + 1;
                                }
                                else
                                    break;
                            }
                            else
                            {
                                countActiveOrderToPrice = countActiveOrderToPrice + 1;
                            }
                        }
                    }
                }
            }
        }


        /// <summary>
        /// ищем заявку с самой далекой ценой на открытие позиции
        /// </summary>
        /// <param name="ldItem"></param>
        public bool SearchOrderForKill(LedderItem ldItem, string Long, string Classcode)
        {
            bool result = false;
            TradesOpen td = new TradesOpen();
            if (Long == "Long")
            {
                double tmpPrice = 1000000000;

                foreach (var item in ldItem.TradeList)
                {
                    if (item.OpenPriceOrder < tmpPrice && item.OpenStatusOrder == cfg.ACTIVE && item.OpenBalance == 0)
                    {
                        tmpPrice = item.OpenPriceOrder;
                        td = item;
                    }
                }
                if (td.OpenNumberOrder != 0)
                {
                    mainWindow.Terminals.CancelOrder(td.OpenNumberOrder, ldItem.Instrument, Classcode, ldItem.Account, ldItem.ClientCode);
                    ldItem.TradeList.Remove(td);
                    return true;
                }
            }
            if (Long == "Short")
            {
                double tmpPrice = 0;

                foreach (var item in ldItem.TradeList)
                {
                    if (item.OpenPriceOrder > tmpPrice && item.OpenStatusOrder == cfg.ACTIVE && item.OpenBalance == 0)
                    {
                        tmpPrice = item.OpenPriceOrder;
                        td = item;
                    }
                }
                if (td.OpenNumberOrder != 0)
                {
                    mainWindow.Terminals.CancelOrder(td.OpenNumberOrder, ldItem.Instrument, Classcode, ldItem.Account, ldItem.ClientCode);
                    ldItem.TradeList.Remove(td);
                    return true;
                }
            }

            return result;
        }



        /// <summary>
        /// Поиск выставленных ордеров по заданным ценам
        /// </summary>
        /// <param name="ld"></param>
        /// <param name="price"></param>
        /// <returns></returns>
        public bool SearchOpenOrderOnPrice(LedderItem ld, double price)
        {
            foreach (var item in ld.TradeList)
            {
                if (item.OpenStatusOrder != null && item.OpenPriceOrder == price)
                    return true;
            }

            return false;
        }

        /// <summary>
        /// Определяем количество актвиных заявок на открытие позиций
        /// </summary>
        /// <param name="ldItem"></param>
        /// <returns></returns>
        public int ActiveOrderOpen(LedderItem ldItem)
        {
            int result = 0;
            if (ldItem.TradeList != null && ldItem.TradeList.Count != 0)
            {
                foreach (var item in ldItem.TradeList)
                {
                    if (item.OpenStatusOrder == cfg.ACTIVE || item.OpenStatusOrder == cfg.UNKNOWN)
                        result = result + 1;
                }
            }

            return result;
        }

        /// <summary>
        /// выставляем заявкку на откртыие позиции и записываем в лист
        /// </summary>
        /// <param name="ldItem"></param>
        /// <param name="Classcode"></param>
        /// <param name="PriceOpen"></param>
        /// <param name="oper"></param>
        private void AddOrderOpenTotradeList(LedderItem ldItem, string Classcode, double PriceOpen, char oper)
        {
            TradesOpen tradesOpen = new TradesOpen();
            tradesOpen.OpenDate = DateTime.Now;
            tradesOpen.OpenID = mainWindow.Terminals.SendOrder(ldItem.Account, ldItem.ClientCode, oper,
                PriceOpen, ldItem.Quantity, ldItem.Instrument, Classcode);
            if (oper == 'B')
                tradesOpen.OpenOperation = "Купля";
            else
                tradesOpen.OpenOperation = "Продажа";
            tradesOpen.OpenPriceOrder = PriceOpen;
            tradesOpen.OpenQuantity = ldItem.Quantity;
            tradesOpen.OpenStatusOrder = cfg.UNKNOWN;
            ldItem.TradeList.Add(tradesOpen);
        }

        /// <summary>
        /// перевыставляем заявкку на откртыие позиции и записываем в лист
        /// </summary>
        /// <param name="ldItem"></param>
        /// <param name="item"></param>
        /// <param name="Classcode"></param>
        /// <param name="PriceOpen"></param>
        /// <param name="oper"></param>
        private void ReplaceOrderOpenTotradeList(LedderItem ldItem, TradesOpen item, string Classcode, double PriceOpen, char oper)
        {
            item.OpenDate = DateTime.Now;
            item.OpenID = mainWindow.Terminals.SendOrder(ldItem.Account, ldItem.ClientCode, oper,
                PriceOpen, item.OpenQuantity - item.OpenBalance, ldItem.Instrument, Classcode);
            item.OpenStatusOrder = cfg.UNKNOWN;
        }

        //выставляем заявкку на закртыие позиции и записываем в лист
        private void AddOrderCloseTotradeList(LedderItem ldItem, TradesOpen item, string Classcode, double PriceClose, char oper)
        {

            item.CloseDate = DateTime.Now;
            item.CloseID = mainWindow.Terminals.SendOrder(ldItem.Account, ldItem.ClientCode, oper,
                PriceClose, ldItem.Quantity - item.CloseBalance, ldItem.Instrument, Classcode);
            if (oper == 'B')
                item.CloseOperation = "Купля";
            else
                item.CloseOperation = "Продажа";
            item.ClosePriceOrder = PriceClose;
            item.CloseQuantity = ldItem.Quantity;
            item.CloseStatusOrder = cfg.UNKNOWN;
        }

        /// <summary>
        /// блок проверки заявок на изменение статуса и баланса
        /// </summary>
        /// <param name="ld"></param>
        public void GetStatusAndBalance(LedderItem ld)
        {
            try
            {
                var orderMassiv = data.GetOrderListAll(ld.Account, ld.ClientCode);
                for (int i = 0; i < ld.TradeList.Count; i++)
                {
                    if (ld.TradeList.Count == 0)
                        break;

                    #region Проверка объема
                    foreach (var item2 in orderMassiv)
                    {
                        //проверка статусов на изменение заявок на открытие пока балансе не равен выставленному числу
                        if (item2.TID == ld.TradeList[i].OpenID && ld.TradeList[i].OpenPriceOrder == item2.Price && ld.TradeList[i].OpenBalance != ld.TradeList[i].OpenQuantity)
                        {
                            ld.TradeList[i].OpenNumberOrder = item2.Number;
                            ld.TradeList[i].OpenStatusOrder = item2.Status;
                            if (ld.TradeList[i].OpenStatusOrder == cfg.PERFORMED)
                            {
                                
                                ld.StaticsticItem.MiddlePriceOpen = (ld.StaticsticItem.MiddlePriceOpen * ld.StaticsticItem.VolOpen + ld.TradeList[i].OpenPriceOrder * ld.TradeList[i].OpenQuantity) / (ld.StaticsticItem.VolOpen + ld.TradeList[i].OpenQuantity);
                                ld.StaticsticItem.VolOpen += ld.Quantity;
                            }
                            if (ld.TradeList[i].OpenQuantity == item2.Count)
                                ld.TradeList[i].OpenBalance = item2.Count - item2.OstCount;
                            else
                            {
                                //если заявка снята либо в конце сеесии либо врунчую и надо выставляться на меньший объем
                                if (ld.TradeList[i].OpenQuantity > ld.TradeList[i].OpenBalance + item2.OstCount)
                                    ld.TradeList[i].OpenBalance = ld.TradeList[i].OpenQuantity - item2.OstCount;
                                if (ld.TradeList[i].OpenQuantity == ld.TradeList[i].OpenBalance + item2.OstCount && item2.OstCount == 0)
                                    ld.TradeList[i].OpenBalance = ld.TradeList[i].OpenQuantity;
                            }
                        }

                        //проверка статусов на изменение заявок на закрытие позиции пока балансе не равен выставленному числу
                        if (ld.TradeList[i].OpenBalance == ld.TradeList[i].OpenQuantity)
                            if (item2.TID == ld.TradeList[i].CloseID && ld.TradeList[i].ClosePriceOrder == item2.Price && ld.TradeList[i].CloseBalance != ld.TradeList[i].CloseQuantity)
                            {
                                ld.TradeList[i].CloseNumberOrder = item2.Number;
                                ld.TradeList[i].CloseStatusOrder = item2.Status;
                                if (ld.TradeList[i].CloseQuantity == item2.Count)
                                    ld.TradeList[i].CloseBalance = item2.Count - item2.OstCount;
                                else
                                {
                                    //если заявка снята либо в конце сеесии либо врунчую и надо выставляться на меньший объем
                                    if (ld.TradeList[i].CloseQuantity > ld.TradeList[i].CloseBalance + item2.OstCount)
                                        ld.TradeList[i].CloseBalance = ld.TradeList[i].CloseQuantity - item2.OstCount;
                                    if (ld.TradeList[i].CloseQuantity == ld.TradeList[i].CloseBalance + item2.OstCount && item2.OstCount == 0)
                                        ld.TradeList[i].CloseBalance = ld.TradeList[i].CloseQuantity;
                                }
                            }
                    }
                    #endregion

                    //если в течении 10 секунд заявка не появилась в системе удалить ее, или ее сняли в ручном формате и не было исполнения, или удаляетс из списка если заявка не определена и уже ее смотрят в другом дне. На закрытие позиции
                    if ((ld.TradeList[i].CloseDate.TimeOfDay + new TimeSpan(0, 0, 10) <= DateTime.Now.TimeOfDay && ld.TradeList[i].CloseStatusOrder == cfg.UNKNOWN)
                        || (ld.TradeList[i].CloseDate.Date != DateTime.Now.Date && (ld.TradeList[i].CloseStatusOrder == cfg.UNKNOWN)))
                    {
                        ld.TradeList.Remove(ld.TradeList[i]);
                        if (i > 0)
                            i--;
                        if (i == 0)
                            break;
                    }

                    //если при переходе в другой день, заявки на закрытие остались активными, то сбросить их в статус null
                    if (ld.TradeList[i].CloseDate.Date != DateTime.Now.Date && ld.TradeList[i].CloseStatusOrder == cfg.ACTIVE)
                        ld.TradeList[i].CloseStatusOrder = null;

                    //если в течении 10 секунд заявка не появилась в системе удалить ее, или ее сняли в ручном формате и не было исполнения, или удаляетс из списка если заявка не определена и уже ее смотрят в другом дне
                    if ((ld.TradeList[i].OpenDate.TimeOfDay + new TimeSpan(0, 0, 10) <= DateTime.Now.TimeOfDay && ld.TradeList[i].OpenStatusOrder == cfg.UNKNOWN)
                        || (ld.TradeList[i].OpenStatusOrder == cfg.CANCEL && ld.TradeList[i].OpenBalance == 0)
                        || (ld.TradeList[i].OpenDate.Date != DateTime.Now.Date && (ld.TradeList[i].OpenStatusOrder == cfg.UNKNOWN || ld.TradeList[i].OpenStatusOrder == cfg.ACTIVE))
                        )
                    {
                        if (ld.TradeList[i].OpenBalance == 0)
                        {
                            ld.TradeList.Remove(ld.TradeList[i]);
                            if (i > 0)
                                i--;
                            if (i == 0)
                                break;
                        }
                        else
                        {
                            ld.TradeList[i].OpenStatusOrder = null;
                        }
                    }

                    if (ld.TradeList[i].OpenStatusOrder == cfg.CANCEL && ld.TradeList[i].OpenBalance != 0)
                    {
                        ld.TradeList[i].OpenStatusOrder = null;
                    }

                    //Заявка на открытие и закрытие исполнились полностью
                    if (ld.TradeList[i].OpenStatusOrder == cfg.PERFORMED && ld.TradeList[i].OpenQuantity == ld.TradeList[i].OpenBalance &&
                        ld.TradeList[i].CloseStatusOrder == cfg.PERFORMED && ld.TradeList[i].CloseQuantity == ld.TradeList[i].CloseBalance)
                    {
                        ld.StaticsticItem.AmountDeals += 1;
                        ld.StaticsticItem.AmountProfit += ld.Quantity * ld.Profit * data.GetLots(ld.Instrument);
                        
                        ld.StaticsticItem.MiddlePriceClose = (ld.StaticsticItem.MiddlePriceClose * ld.StaticsticItem.VolClose + ld.TradeList[i].ClosePriceOrder * ld.TradeList[i].CloseQuantity) / (ld.StaticsticItem.VolClose + ld.TradeList[i].CloseQuantity);
                        ld.StaticsticItem.VolClose += ld.Quantity;
                        ld.TradeList.Remove(ld.TradeList[i]);
                        if (i > 0)
                            i--;
                        if (i == 0)
                            break;
                    }
                }
            }
            catch
            { }
        }


        //Блок определения актвиных и неизвестных заявок на открытие позиции, для перестановки заявки в случае исполнения профита или подтягивания к цене

    }
}
